Regular Research Papers:

• Jeroen Weijers, Jurriaan Hage and Stefan Holdermans. Security Type Error Diagnosis for Higher-Order, Polymorphic Languages
  
  Abstract: We combine the type error slicing and heuristics based approaches to type error diagnostic improvement within the context of type based security analysis on a let-polymorphic call by value lambda calculus extended with lists, pairs and the security specific constructs declassify and protect. We define and motivate four classes of heuristics that help diagnose inconsistencies among the constraints, and show their effect on a selection of security incorrect programs.

• Marco Servetto and Elena Zucca. A meta-circular language for active libraries
  
  Abstract: We present a new Java-like language design coupling disciplined meta-programming features with a composition language. That is, programmers can write meta-expressions that combine class definitions, on top of a small set of composition operators, inspired by the seminal Bracha's Jigsaw framework. Moreover, such operators are deep, that is, they allow to manipulate (e.g., rename or duplicate) a nested class at any level of depth.
  
  This provides an effective language support for active libraries: namely, a (library) class can provide a method returning a customized version of a class, depending, e.g., on the execution platform. Since a class can contain nested classes, a whole library can be generated in this way. That is, deep operators allows the programmer to better exploit meta-programming capabilities, leading to a "meta-programming in the large" style.
  
  We adopt a mixed typechecking technique, which provides a good compromise between meta-programming systems with extreme expressiveness and no static type checking, and those with strong type system and only limited meta-programming capability. In particular, our technique ensures an important property, called meta-level soundness, stating that typing errors never originate from already compiled (meta-)code, that is, programmers can safely use (active) libraries.

• Álvaro García-Pérez and Pablo Nogueira. A Syntactic and Functional Correspondence between Reduction Semantics and Reduction-Free Full Normalisers
  
  Abstract: Olivier Danvy and others have shown the syntactic correspondence between reduction semantics (a small-step semantics) and abstract machines, as well as the functional correspondence between reduction-free normalisers (a big-step semantics) and abstract machines. The correspondences are established by program-transformation (so-called interderivation) techniques. A reduction semantics and a reduction-free normaliser are interderivable when the abstract machine obtained from them is the same. However, the correspondences fail when the underlying reduction strategy is hybrid, i.e., relies on another sub-strategy. Hybridisation is an essential structural property of full-reducing and complete strategies. Hybridisation is unproblematic in the functional correspondence. But in the syntactic correspondence the refocusing and inlining-of-iterate-function steps become context sensitive, preventing the refunctionalisation of the abstract machine. We show how to solve the problem and showcase the interderivation of normalisers for normal order, the standard, full-reducing and complete strategy of the pure lambda calculus. Our extension makes it possible to interderive, rather than contrive, full-reducing abstract machines. As expected, the machine we obtain is a variant of Pierre Crégut's full Krivine machine KN.

• Qiang Sun, Yuting Chen and Jianjun Zhao. Constraint-Based Locality Analysis for X10 Programs
  
  Abstract: X10, a HPC (High Performance Computing) programming language proposed by IBM, supports a PGAS (Partitioned Global Address Space) programming model offering a shared address space. The address space can be further partitioned into several logical locations where objects and activities (or threads) will be dynamically created. An analysis of locations can help to check the safety of object accesses through exploring which objects and activities may reside in which locations, while in practice the objects and activities are usually designated at runtime and their locations may also vary under different environments. In this paper, we propose a constraint-based locality analysis method called Leopard for X10. Leopard calculates the points-to relations for analyzing the objects and activities in a program and uses a place constraint graph to analyze their locations. We have developed a tool to support Leopard, and conducted an experiment to evaluate its effectiveness and efficiency. The experimental results show that Leopard can calculate the locations of objects and activities precisely.

• Bruno Oliveira and Andres Loh. Abstract Syntax Graphs for Domain Specific Languages
  
  Abstract: This paper shows a Haskell representation for embedded domain specific languages (EDSLs) using abstract syntax graphs (ASGs). The purpose of this representation is to deal with the important problem of defining operations that require observing or preserving sharing and recursion in EDSLs in an expressive, yet easy to use way. In contrast to more conventional representations based on abstract syntax trees, ASGs represent sharing and recursion explicitly as binder constructs. We use a functional representation of ASGs based on structured graphs, where binders are encoded with parametric higher-order abstract syntax. We show how adapt to this representation to well-typed ASGs. This is especially useful for EDSLs, which often reuse the type system of the host language. We also show a type-class based encoding of (well-typed) ASGs that enables extensible and modular well-typed EDSLs while allowing the manipulation of sharing and recursion.

• Emanuele De Angelis, Fabio Fioravanti, Alberto Pettorossi and Maurizio Proietti. Verifying Programs via Iterated Specialization
  
  Abstract: We present a method for verifying safety properties of imperative programs by using techniques based on the specialization of constraint logic programs (CLP). We consider a class of C programs with integer variables, and we define their operational semantics as a reachability relation between memory configurations. Then we address the problem of verifying safety properties, stating that error configurations cannot be reached from initial configurations.
  
  The reachability relation is encoded as a CLP program R, and the safety property to be verified is encoded as the negation of a predicate unsafe in R, meaning that an {error} configuration can be reached from the initial configuration.
  
  Then, we check whether or not the safety property holds by specializing the CLP program R with respect to the given C program, initial and error configurations, so as to derive a new CLP program R_s where the evaluation of unsafe either finitely fails (safety holds) or succeeds (safety does not hold). The program specialization strategy we propose always terminates, but due to the undecidability of safety properties, it may be the case that in the residual program R_s we are not able to decide whether unsafe finitely fails or succeeds.
  
  Then, we apply again program specialization and iterate this process in the hope of proving safety or unsafety. During the various specializations we may apply different strategies for propagating information (e.g., forward propagation from an initial configuration, or backward propagation from an error configuration) and different operators for generalizing predicate definitions (e.g., widening and convex hull).
  
  We have implemented the various strategies using the MAP transformation system. By an experimental evaluation on various examples taken from the literature, we show that our method is competitive with respect to state-of-the-art software model checkers.

• Ryosuke Sato, Hiroshi Unno and Naoki Kobayashi. Towards a Scalable Software Model Checker for Higher-Order Programs
  
  Abstract: In our recent paper, we have shown how to construct a fully-automated program verification tool (so called a "software model checker") for a tiny subset of functional language ML, by combining higher-order model checking, predicate abstraction, and CEGAR. This can be viewed as a higher-order counterpart of previous software model checkers for imperative languages like BLAST and SLAM. The naive application of the proposed approach, however, suffered from scalability problems, both in terms of efficiency and supported language features. To obtain more scalable software model checkers for full-scale functional languages, we propose several optimizations and extensions of the previous approach. Among others, we introduce (i) selective CPS transformation, (ii) selective predicate abstraction, (iii) refined predicate discovery as optimization techniques, and (iv) functional encoding of recursive data structures and control operations to support a larger subset of ML. We have implemented the proposed methods, and obtained promising results.

• Dominique Devriese, Ilya Sergey, Dave Clarke and Frank Piessens. Fixing Idioms - A recursion primitive for applicative DSLs
  
  Abstract: In a lazy functional language, the standard encoding of recursion in DSLs uses the host language's recursion, so that DSL algorithms automatically use the host language's least fixpoints, even though many domains require algorithms to produce different fixpoints. In particular, this is the case for DSLs implemented as Applicative functors (structures with a notion of pure computations and function application). We propose a recursion primitive afix that models a recursive binder in a finally tagless HOAS encoding, but with a novel rank-2 type that allows us to specify and exploit the effects-values separation that characterizes Applicative DSLs. Unlike related approaches for Monads and Arrows, we model effectful recursion, not value recursion.
  
  Using generic programming techniques, we define an arity-generic version of the operator to model mutually recursive definitions. We recover intuitive user syntax with a form of shallow syntactic sugar: an alet construct that syntactically resembles the let construct, which we have implemented in the GHC Haskell compiler. We describe a proposed axiom for the afix operator. We demonstrate usefulness with examples from Applicative parser combinators and functional reactive programming. We show how higher-order recursive operators like many can be encoded without special library support, unlike previous approaches, and we demonstrate an implementation of the left recursion removal transform.

• Axel Simon. Deriving a Complete Type Inference for Hindley-Milner and Vector Sizes using Expansion
  
  Abstract: Type inference and program analysis both infer static properties about a program. Yet, they are constructed using very different techniques. We reconcile both approaches by deriving a type inference from a denotational semantics using abstract interpretation. We observe that completeness results in the abstract interpretation literature can be used to derive type inferences that are abstract-complete, a property akin to the inference of principal typings. The resulting algorithm is similar to that of Milner-Mycroft, that is, it infers Hindley-Milner types while allowing for polymorphic recursion. Instead of type schemes, it uses expansion to instantiate types. Since our expansion operator is agnostic to the abstract domain, we are able to apply it not only to types. We illustrate this by inferring the size of vector types using systems of linear equalities.

• Francisco Javier López-Fraguas and Enrique Martin-Martin. Typing as Functional-Logic Evaluation
  
  Abstract: We present a transformational approach to type inference for functional logic programs. More concretely, we give a wide set of examples showing how, given a functional logic program P, we can synthesize a remarkably simple and natural functional logic program P' such that the evaluation of expressions with respect to P' corresponds to typing the expressions in the original P. We start developing those ideas for the case of type inference with standard Hindley-Milner types, and after that we consider some variations, like local definitions with different degrees of polymorphism, existential types, or type checking in presence of polymorphic recursion. For the basic case of Hindley-Milner types we provide also a formalization of the transformation and proofs of its adequacy. Besides its potential applicability to the implementation of different type systems, or to the educational use of the synthesized typing programs to explain different type inference/checking processes, the paper demonstrates vividly the expressive power of functional logic languages, as well as some of their limitations to the purpose of metaprogramming, that we have overcome by providing a suitable set of metalogical functions to inspect, classify and manipulate expressions according to their structure, similar to well known Prolog metapredicates for such purposes.

• Kostis Sagonas, Josep Silva and Salvador Tamarit. Precise Explanation of Success Typing Errors
  
  Abstract: Nowadays, many dynamic languages come with (some sort of) type inference in order to detect type errors statically. Often, in order not to unnecessarily reject programs which are allowed under a dynamic type discipline, their type inference algorithms are based on non-standard (i.e., not Hindley-Milner based) type inference techniques and employ aggressive forwards and backwards propagation of subtype constraints. Although such analyses are effective in locating real errors, the type errors they report are often extremely difficult for programmers to follow and convince themselves that something should be changed in their programs.
  
  We have observed this phenomenon in the context of Erlang: for a number of years now its implementation comes with a static analysis tool called Dialyzer which, among other software discrepancies, detects definite type errors (i.e., code points that will result in a runtime error if executed) by inferring success typings.
  
  In this work, we extend the analysis that infers success typings, with infrastructure that maintains additional information that can be used to provide precise (i.e., minimal) explanations about the cause of a discrepancy reported by Dialyzer using program slicing.
  
  An interesting aspect of the information that our analysis gathers is that it is not useful only for explaining definite type errors but also places in the code containing unreachable statements, dead code, etc., i.e. discrepancies which would normally be undetected by most type inference, static analysis, or testing techniques.
  
  We have implemented the techniques we describe in a publicly available development branch of Dialyzer.

• Bruno Martinez, Marcos Viera and Alberto Pardo. Just Do It While Compiling!: Fast Extensible Records in Haskell
  
  Abstract: The library for strongly typed heterogeneous collections HList provides an implementation of extensible records in Haskell that needs only a few common extensions of the language. In HList, records are represented as linked lists of label-value pairs with a look-up operation that is linear-time in the number of fields. In this paper, we use type-level programming techniques to develop a more efficient representation of extensible records for HList. We propose two internal encodings for extensible records that improve lookup at runtime without needing a total order on the labels. One of the encodings performs lookup in constant time but at a cost of linear time insertion. The other one performs lookup in logarithmic time while preserving the fast insertion of simple linked lists. Through staged compilation, the required slow search for a field is moved to compile time in both cases.

• María Alpuente, Marco A. Feliú and Alicia Villanueva. Automatic Inference of Specifications using Matching Logic
  
  Abstract: Formal specifications can be used for various software engineering activities ranging from finding errors to documenting software and automatic test-case generation. Automatically discovering specifications for heap-manipulating programs is a challenging task. In this paper, we propose a technique for automatically inferring formal specifications from code which is based on the symbolic execution and automated reasoning tandem "Matching Logic / K framework". We implemented our technique for a fragment of C, called KernelC^?, in the automated tool KingSpec^?, which generates axioms that describe the precise input/output behavior of C routines that handle pointer-based structures, i.e., result values and state change. These specifications can be written either in Matching Logic itself, which is useful for further automated analysis within the K formal environment, or in sugared axiomatic form, which favors better human inspection. Since we rely on rewriting logic K semantics specification of programming languages, our approach can be easily extended to any language for which a formal semantics in K is given.

Tool Demonstration Papers:

• Martin Sulzmann, Jürgen Nicklisch and Axel Zechner. Traceability and Correctness of EDSL Abstractions
  
  Abstract: EDSLs (embedded domain-specific languages) are in particular suitable for agile software projects. New abstractions can be coded quickly and easily in the EDSLs host language and are automatically transformed to the basic primitives of the EDSLs. In the context of formal software certification, it is paramount that these abstractions are correct and that the low-level code resulting from the EDSL primitives can be traced to some higher-level artifacts, let it be some concrete programming abstractions, software requirements etc. We have built an EDSL-based toolchain for implementing and testing mission critical applications which supports measures to guarantee traceability and correctness of EDSL abstractions. We give an overview of our approach and practical experiences applying the EDSLs in the industrial context.

• Marco Comini and Luca Torella. TRSynth: a Tool for Automatic Inference of Term Equivalence in Left-linear Term Rewriting Systems
  
  Abstract: This paper presents a technique to automatically infer algebraic property-oriented specifications from Term Rewriting Systems. Namely, given the source code of a TRS we infer a specification which consists of a set of equations relating (nested) terms (operation calls) that rewrite to the same set of values.
  
  In this paradigm there are several additional issues which arises with respect to the (first order) functional programming case, because free variables are admitted in queries and non-constructor-based rules are allowed.
  
  The (glass-box) semantic-based inference method that we propose can cope with this issues and achieves, to some extent, the correctness of the inferred specification, differently from other (black-box) approaches based on testing techniques.
  
  To experiment on the validity of our proposal we have considered an instance of the proposed method employing a novel (condensed) semantics for left-linear TRSs and we have implemented a "proof of concept" prototype in Haskell which is available online.

Short Papers:

• Michael Carbin, Deokhwan Kim, Sasa Misailovic and Martin Rinard. Verified Integrity Properties for Safe Approximate Program Transformations
  
  Abstract: Approximate computations (for example, video, audio, and image processing computations, machine learning computations, and many scientific computations) have the freedom to generate a range of acceptable results. Approximate program transformations (for example, task skipping and loop perforation) exploit this freedom to produce computations that can execute at a variety of points in an underlying accuracy versus performance trade-off space. One potential concern is that these transformations may change the semantics of the program and therefore cause the program to crash, perform an illegal operation, or otherwise violate its integrity.
  
  We investigate verifying integrity properties -- key correctness properties that the transformed computation must respect -- to safely apply approximate program transformations. We present our experience developing and evaluating a compiler that verifies integrity properties of computations expressed as `for' loops, then leverages these verified properties to safely apply transformations that perforate the loops.

• Baris Aktemur, Yukiyoshi Kameyama, Oleg Kiselyov and Chung‐chieh Shan. Shonan Challenge for Generative Programming (Short Position Paper)
  
  Abstract: The appeal of generative programming is "abstraction without guilt": eliminating the vexing trade-off between writing high-level code and highly-performant code. Generative programming also promises to formally capture the domain-specific knowledge and heuristics used by high-performance computing (HPC) experts. How far along are we in fulfilling these promises? To gauge our progress, a recent Shonan Meeting on "bridging the theory of staged programming languages and the practice of high-performance computing" proposed to use a set of benchmarks, dubbed "Shonan Challenge".
  
  Shonan Challenge is a collection of crisp problems posed by HPC and domain experts, for which efficient implementations are known but were tedious to write and modify. The challenge is to generate a similar efficient implementation from the high-level specification of a problem, performing the same optimizations, but automatically. It should be easy to adjust optimizations and the specification, maintaining confidence in the generated code.
  
  We describe our initial set of benchmarks and provide two solutions to one of the problems. We hope that the Shonan Challenge will clarify the state of the art and stimulate the theory and technology of staging just as the POPLmark challenge did for meta-theory mechanization. Since each Shonan Challenge problem is a kernel of a significant HPC application, each solution has an immediate practical application.

Invited Speakers

We are proud to present the following two invited talks:

• Zhenjiang Hu (National Institute of Informatics, Japan): Practical Aspects of Bidirectional Graph Transformations
  
  Abstract Bidirectional transformations provide a novel mechanism for synchronizing and maintaining the consistency of information between input and output. Despite many promising results on bidirectional transformations, most of them are limited to lists and trees. We have challenged the problem of bidirectional transformations on graphs, and succeeded in implementing a bidirectional graph transformation engine called GRoundTram. In GRoundTram, graphs are treated as regular trees and manipulated by structural recursion that enjoys a nice bulk and bidirectional semantics. In this talk, I'd briefly explain our solution to the problem of bidirectional graph transformation, demonstrate some applications in bidirectional model-driven software development, and discuss practical challenges in manipulating various graphs (such as unordered, ordered, and probability graphs), determining backward transformation, and improving efficiency and scalability.
  
  
• Peter Thiemann (Institut für Informatik, Technische Fakultät, Universität Freiburg, Germany): Partially Static Operations
  
  Abstract Partial evaluation assigns binding times to values manipulated in a program. A partial evaluator processes values with a static binding time whereas a dynamic binding time mandates code generation. Binding time descriptions have evolved from monolithic to fine grained, partially static data structures where different components may have different binding times.
  
  We consider the next step in this evolution where not just data structures but also operations can give rise to partially static structures, which are processed by the partial evaluator. We introduce this notion in an online setting, generalize it, generate a binding-time analysis for it, and implement an offline partial evaluator supporting partially static operations with it. We report on our initial experiences with this new approach.

Program Committee

Program Chairs

• Elvira Albert (Complutense University of Madrid, Spain)
• Shin-Cheng Mu (Academia Sinica, Taiwan)

Program Committee Members

• María Alpuente (Technical University of Valencia, Spain)
• Kenichi Asai (Ochanomizu University, Japan)
• Maria Garcia de la Banda (Monash University, Australia and IMDEA Software Institute, Spain)
• James R. Cordy (Queen's University, Canada)
• R. Kent Dybvig (Cisco and Indiana University, USA)
• João Paulo Fernandes (University of Beira Interior, Portugal)
• Samir Genaim (Complutense University of Madrid, Spain)
• Roberto Giacobazzi (Verona University, Italy)
• Andy Gill (University of Kansas, USA)
• Jurriaan Hage (Utrecht University, Netherlands)
• Martin Hofmann (Ludwig-Maximilians-Universität München, Germany)
• Julia Lawall (Inria, France)
• Yanhong Annie Liu (Stony Brook University, USA)
• Kazutaka Matsuda (University of Tokyo, Japan)
• Keisuke Nakano (University of Electro-Communications, Japan)
• Klaus Ostermann (University of Marburg, Germany)
• Sergei A. Romanenko (Russian Academy of Sciences, Russia)
• Jeremy G. Siek (University of Colorado at Boulder, USA)
• Walid Mohamed Taha (Halmstad University, Sweden, and Rice University, USA)
• Tarmo Uustalu (Institute of Cybernetics, Tallinn, Estonia)
• Janis Voigtländer (University of Bonn, Germany)
• Dana N. Xu (Inria, France)

Steering Committee

• Elvira Albert (Complutense University of Madrid, Spain)
• Siau-Cheng Khoo (National University of Singapore, Singapore)
• Oleg Kiselyov (Monterey, CA, USA)
• Shin-Cheng Mu (Academia Sinica, Taiwan)
• Jeremy G. Siek (University of Colorado at Boulder, USA)
• Simon Thompson (University of Kent, UK)

----------------------------------------------------------------------
                            Call For Papers 

                     ACM SIGPLAN 2010 Workshop on 
         PARTIAL EVALUATION AND PROGRAM MANIPULATION (PEPM'10)

                             Madrid, Spain
                          January, 2010 
                     (Co-located with POPL 2010)

             http://www.program-transformation.org/PEPM10
----------------------------------------------------------------------

The PEPM Symposium/Workshop series aims to bring together researchers
and practitioners working in the areas of program manipulation,
partial evaluation, and program generation. PEPM focuses on
techniques, theory, tools, and applications of analysis and
manipulation of programs.

The 2010 PEPM workshop will be based on a broad interpretation of
semantics-based program manipulation and continue previous years'
successful effort to expand the scope of PEPM significantly beyond the
traditionally covered areas of partial evaluation and specialization
and include practical applications of program transformations such as
refactoring tools, and practical implementation techniques such as
rule-based transformation systems. In addition, the scope of PEPM
covers manipulation and transformations of program and system
representations such as structural and semantic models that occur in
the context of model-driven development. In order to reach out to
practitioners, a separate category of tool demonstration papers will
be solicited.

----------------------------------------------------------------------

Topics of interest for PEPM'10 include, but are not limited to:

 + Program and model manipulation techniques such as transformations
   driven by rules, patterns, or analyses, partial evaluation,
   specialization, program inversion, program composition, slicing, 
   symbolic execution, refactoring, aspect weaving, decompilation, 
   and obfuscation. 

 + Program analysis techniques that are used to drive program/model
   manipulation such as abstract interpretation, static analysis,
   binding-time analysis, dynamic analysis, constraint solving, and
   type systems.

 + Analysis and transformation for programs/models with advanced
   features such as objects, generics, ownership types, aspects,
   reflection, XML type systems, component frameworks, and middleware.

 + Techniques that treat programs/models as data objects including
   meta-programming, generative programming, staged computation, and
   model-driven program generation and transformation.

 + Application of the above techniques including experimental studies,
   engineering needed for scalability, and benchmarking. Examples of
   application domains include legacy program understanding and
   transformation, domain-specific language implementations,
   scientific computing, middleware frameworks and infrastructure
   needed for distributed and web-based applications, resource-limited
   computation, and security.

We especially encourage papers that break new ground including
descriptions of how program/model manipulation tools can be integrated
into realistic software development processes, descriptions of robust
tools capable of effectively handling realistic applications, and new
areas of application such as rapidly evolving systems, distributed and
webbased programming including middleware manipulation, model-driven
development, and on-the-fly program adaptation driven by run-time or
statistical analysis.

----------------------------------------------------------------------

Submission Categories and Guidelines

Regular research papers must not exceed 10 pages in ACM Proceedings
style. Tool demonstration papers must not exceed 4 pages in ACM
Proceedings style, and authors will be expected to present a live
demonstration of the described tool at the workshop. Suggested topics,
evaluation criteria, and writing guidelines for both research tool
demonstration papers will be made available on the PEPM'10 web
site. Papers should be submitted electronically via the workshop web
site. The workshop proceedings will be published in the ACM Digital
Library and selected papers may be invited for a journal special
issue dedicated to PEPM'10.

----------------------------------------------------------------------

Important Dates 

 + to be announced
 + Abstracts due:  
 + Submission:    
 + Notification:   
 + Camera-ready:   
 + Workshop:      January, 2010 

-----------------------------------------------------------------------

Program Chairs

    * John Gallagher (Roskilde University, Denmark)
    * Janis Voigtlaender (Technische Universitaet Dresden, Germany)

Program Committee Members

    * to be announced

-----------------------------------------------------------------------

POPL 2010

-- JanisVoigtlaender - 18 Jun 2009

• GPCE06-FirstCallForPapers.pdf: Flyer with first call for papers for GPCE'06

Mon-Tue, January 21-22, 2013
Rome, Italy
co-located with POPL'13

Sponsored by ACM SIGPLAN

http://www.program-transformation.org/PEPM13

Submissions

10 pages in SIGPLAN proceedings style (sigplanconf.cls) reporting research results and/or experience related to the topics above (PC co-chairs can advise on appropriateness). We particularly encourage original high-quality reports on applying GPCE technologies to real-world problems, relating ideas and concepts from several topics, or bridging the gap between theory and practice.

Papers

Acceptance Rate

Participants

• Abstract due: Tue, October 2, 2012 (extended!)
• Paper submission: Sun, October 7, 2012, 23:59, GMT (extended!)
• Author notification: Tue, November 6, 2012
• Camera-Ready Paper: Wed, November 14, 2012

Electronic Submission

Papers must be submitted electronically in PDF format at

• http://www.easychair.org/conferences/?conf=pepm13

Example Paper Types

• New transformation technique: The most common type of PEPM paper will report on a new analysis/transformation technique. Such papers should include a detailed description of the technique, some sort of formal or informal argument about why the technique is correct, illustrate the technique on interesting examples, and evaluate the effectiveness of the technique.
• Case studies: This type of paper reports on a large-scale application of an existing technique. Such papers should clearly state the insights and the lessons of the study. Was the technique effective? Was it easy to apply? What pitfalls were overcome and what difficulties remain? One must clearly distinguish anecdotal performance claims from rigorously established ones.
• Description of new/interesting domain and potential for effective use of PEPM techniques: This type of paper describes a particular application domain (e.g., middleware, avionics systems, active networks) or a particular development paradigm (e.g., model-driven development) detailing how techniques within the scope of PEPM might be applied effectively in that domain. Special attention should be given to enumerating the problems/challenges of the domain, characteristics that suggest that it might benefit from PEPM techniques, initial attempts at applying those techniques, and questions/challenges to be addressed by future work. Such papers should aim to educate the PEPM community about interesting/fundamental issues of the domain, and give pointers to where they may learn more about the issues.

Short papers

We do encourage submissions of "work in progress" in cases where the submission raises issues that will generate interesting discussions at the meeting, brings new knowledge of a particular application domain or technique to the community, or lays out challenging open problems of high relevance to software engineering practice. Depending on the quality and number of such submissions, we may collect work-in-progress papers into a single session with slightly shorter time slots for each presentation and a longer discussion time at the end of the session.

• Andy Gill, Garrin Kimmell and Kevin Matlage. Capturing Functions and Catching Satellites.
  
  Abstract: The 2009 ICFP contest required the programming of virtual satellites that obey basic physical laws. The orbital physics of the system ran on top of a simple virtual machine which was customized via a binary provided to contestants. In our talk, we describe the modeling of our simulation environment, with a focus on the compilation and testing infrastructure for the generated binaries. This infrastructure makes novel use of a deeply embedded domain specific language on top of Haskell. In particular, with use of IO-based observable sharing, it is straightforward for a function to be both an executable specification as well as a portable implementation.

Journal special issues of selected papers from PEPM meetings

• Special issue of Higher-Order and Symbolic Computation for PEPM'12, forthcoming
• Special issue of Higher-Order and Symbolic Computation for PEPM'10
• Special issue of Higher-Order and Symbolic Computation for PEPM'09
• Special issue of Science of Computer Programming for PEPM'07, volume 76, number 6, 2011
• Special issue of Higher-Order and Symbolic Computation for PEPM'04, volume 21, numbers 1-2, 2008
• Special issue of Higher-Order and Symbolic Computation for PEPM'02 and ASIA-PEPM'02, volume 17, numbers 1-2, 2004
• Special issue of Higher-Order and Symbolic Computation for PEPM'02, volume 16, number 4, 2003
• Special issue of Higher-Order and Symbolic Computation for PEPM'00, volume 14, numbers 2-3, 2001
• Special issue of Higher-Order and Symbolic Computation for PEPM'99, volume 13, number 4, 2000
• Special issue of Higher-Order and Symbolic Computation for PEPM'99, volume 12, number 4, 1999
• Special issue of New Generation Computing for Partial Evaluation and Program Transformation Day 1999, volume 20, number 1, 2002
• Special issue of Theoretical Computer Science for PEPM'97, volume 248, numbers 1-2, 2000
• Special issue of Lisp and Symbolic Computation for PEPM'94, volume 8, number 3, 1995
• Special issue of New Generation Computing for WPEMC'87, volume 6, numbers 2-3, 1988

• Symposium on Partial Evaluation (virtual). ACM Computing Surveys (CSUR), volume 30, number 3, 1998
• Special issue of Journal of Functional Programming on Partial Evaluation, volume 3, number 3, 1993
• Special issue of Journal of Logic Programming on Partial Deduction, volume 16, numbers 1-2, 1993

• Elvira Albert (Complutense University of Madrid, Spain)
• Siau-Cheng Khoo (National University of Singapore, Singapore)
• Oleg Kiselyov (Monterey, CA, USA)
• Shin-Cheng Mu (Academia Sinica, Taiwan)
• Jeremy G. Siek (University of Colorado at Boulder, USA)
• Simon Thompson (University of Kent, UK)

Tuorial Submission Format

Proposals must be submitted electronically via e-mail, as plain text or in PDF, according to the following template:

1. Title
   • The title expresses the contents of the tutorial well without being too long.
   • An effective title attracts participants' curiosity.
2. Speaker(s)
   • Give the full name and address of the tutorial speaker(s).
   • If there is more than one speaker, a contact person should be clearly designated.
   • Don't forget to specify the electronic mail address.
3. Abstract (to appear in the Advance Program)
   • The abstract should concisely describe the contents and goals of the tutorial.
   • It should not be longer than 150 words.
4. Outline (to present to the committee the proposed contents of the tutorial)
   • The outline should present a table of contents as a sequence of sections.
   • Each section should be described with a few brief sentences or keywords
   • For each section, an estimate should be given of the time to be spent.
5. Duration
   • Tutorials can be half-day or full-day. Half-day tutorials are preferred.
   • A half-day tutorial lasts for about 3 1/2 hours, including a 1/2 hour break.
   • A full-day tutorial lasts for about 8 hours, including two 1/2 hour breaks, and a 1 hour lunch break.
6. Level
   • The tutorial level can be introductory, intermediate or advanced
7. Required Knowledge (to appear in the Advance Program)
   • The proposal should state the specific knoweldge or skills expected of your participants.
   • The statement should not be longer than 20 words.
8. Expected audience
   • The proposal must describe typical or expected participants.
   • The proposal must outline the benefits to participants (e.g., in use of new skills or application of new knowledge).
9. Extended speaker profile
   • The affiliation, interests, and experience of each speaker must be provided.
   • The profile should clearly explain why the speaker is the right person to give the tutorial.
10. Summary speaker profile (to appear in Advance Program)
    • Provide a short version of the Speaker's profile to be included in the Advance Program.
    • It should not be longer than 40 words.
11. Tutorial resume
    • The Resume describes previous offerings of the tutorial, if any.
    • If previously offered, provide the number and level of previous participants.
    • If available, include ratings of the tutorial as evaluated by previous participants.
12. Equipment requirements
    • The proposal should specify the equipment required.
    • The conference organizers can arrange for slide projectors, video projection facilities, tables, power plugs, and paper boards.
    • Participants may be expected to bring computing equipment.
13. Actual Presentation Materials
    • The proposal may include previously prepared tutorial materials such as slides or handouts: these are not required for submmission, however.
    • Submitted actual presentation materials show depth and maturity of the tutorial.
    • Even for a new tutorial a few sample slides would help the committee judge the expected quality of the presentation.

The tutorial submission should be contained within five pages (excluding any materials submitted under item 13 above). Various parts of the proposal for accepted tutorials may be edited for incorporation in the Advance Program.

Back to the CallForTutorials^?.

Regular Research Papers must not exceed 10 pages in ACM Proceedings style. Tool demonstration papers and short papers must not exceed 4 pages in ACM Proceedings style. At least one author of each accepted contribution must attend the workshop and present the work. In the case of tool demonstration papers, a live demonstration of the described tool is expected. Suggested topics, evaluation criteria, and writing guidelines for both research tool demonstration papers will be made available on the PEPM'13 Web-site. Papers should be submitted electronically via the workshop web site.

Authors using Latex to prepare their submissions should use the new improved SIGPLAN proceedings style (sigplanconf.cls, 9pt template).

Monday, January 18, 2010

Chairs' Welcome: 9:00 - 9:05

Invited Talk 1: 9:05 - 10:05

• Lennart Augustsson: O, Partial Evaluator, Where Art Thou?

Coffee break

Session 1: 10:30 - 11:30 (Java/Scala Types)

Session Chair: Jeremy G. Siek (University of Colorado at Boulder)

• Nabil el Boustani and Jurriaan Hage. Corrective Hints for Type Incorrect Generic Java Programs.
• Johannes Rudolph and Peter Thiemann. Mnemonics: Type-safe Bytecode Generation at Run Time.

Coffee break

Session 2: 12:00 - 13:00 (Tools 1)

Session Chair: Peter Thiemann (University of Freiburg)

• Elvira Albert, Miguel Gomez-Zamalloa and German Puebla. PET: A Partial Evaluation-based Test Case Generation Tool for Java Bytecode.
• Martin Hofmann. Igor2 - an Analytical Inductive Functional Programming System.

Lunch

Session 3: 14:30 - 15:30 (Program Transformation)

Session Chair: Elvira Albert (Complutense University of Madrid)

• José Pedro Magalhães, Stefan Holdermans, Johan Jeuring and Andres Löh. Optimizing Generics Is Easy!
• Michele Baggi, María Alpuente, Demis Ballis and Moreno Falaschi. A Fold/Unfold Transformation Framework for Rewrite Theories extended to CCT.

Coffee break

Session 4: 16:00 - 17:00 (Termination)

Session Chair: Stefan Holdermans (Utrecht University)

• Hugh Anderson and Siau-Cheng KHOO. Regular Approximation and Bounded Domains for Size-Change Termination.
• Évelyne Contejean, Pierre Courtieu, Julien Forest, Andrei Paskevich, Olivier Pons and Xavier Urbain. A3PAT, an Approach for Certified Automated Termination Proofs.

Break

Video Talk: 17:15 - 17:40

• Andy Gill, Garrin Kimmell and Kevin Matlage. Capturing Functions and Catching Satellites.

Tuesday, January 19, 2010

Invited Talk 2: 9:00 - 10:00

• Jeremy G. Siek. General Purpose Languages Should be Metalanguages.

Coffee break

Session 5: 10:30 - 11:30 (Innovative Programming)

Session Chair: Nate Foster (University of Pennsylvania)

• Fritz Henglein. Optimizing Relational Algebra Operations Using Generic Equivalence Discriminators and Lazy Products.
• Adrian Riesco and Juan Rodriguez-Hortala. Programming with Singular and Plural Non-deterministic Functions.

Coffee break

Session 6: 12:00 - 13:00 (Synthesis and Compilation)

Session Chair: Jurriaan Hage (Utrecht University)

• Martin Hofmann and Emanuel Kitzelmann. I/O Guided Detection of List Catamorphisms.
• Andrew Moss and Dan Page. Bridging the Gap Between Symbolic and Efficient AES Implementations.

Lunch

Session 7: 14:30 - 15:30 (Haskell Analysis/Transformation)

Session Chair: German Puebla (Technical University of Madrid)

• Christopher Brown and Simon Thompson. Clone Detection and Elimination for Haskell.
• Stefan Holdermans and Jurriaan Hage. Making Stricterness More Relevant.

Coffee break

Session 8: 16:00 - 17:00 (Static Analysis Techniques)

Session Chair: Fritz Henglein (University of Copenhagen)

• Arun Lakhotia, Davidson Boccardo, Anshuman Singh and Aleardo Manacero Júnior. Context-Sensitive Analysis of Obfuscated x86 Executables.
• Xin Li and Mizuhito Ogawa. Conditional Weighted Pushdown Systems and Applications.

Break

Session 9: 17:15 - 18:15 (Tools 2)

Session Chair: Simon Thompson (University of Kent)

• Ivan Lazar Miljenovic. The SourceGraph Program.
• Florian Haftmann. From Higher-Order Logic to Haskell: There and Back Again.

Tool demo paper submissions must satisfy the following requirements.

• The body of the paper must be no longer than 4 pages in length using the two-column ACM Conference style. The body of the paper should give an overview of the tool, the methodology associated with its use, a summary of how the tool has been applied and to what effect, and it should indicate what supporting artifacts (user manual, example repository, downloads, etc.) are available. This material will be included in the PEPM proceedings for accepted tool demos. The paper should include the following two items:
• an appendix (limited to six pages) that gives an outline of the proposed demo presentation (this material will NOT appear in the PEPM proceedings), and
• a URL to a web-site giving documentation and further information about the tool.

Because tool papers have a different format and a different purpose than regular research papers, we would like to (a) describe in more detail the characteristics of a good tool paper, and (b) give the explicit evaluation criteria that will be used by the PEPM program committee when selecting tool papers.

Regular research papers may also describe the details of a particular tool, but note that there are important differences between the contents of a tool demo paper and a research paper that describes a tool. Research papers about tools clearly describe how aspects of the tool (e.g., its architecture, underlying algorithms, combinations of techniques, functionality, etc.) advance the state of the art. This should include a detailed comparison with related work. Moreover, research papers about tools should usually include the results/data of experimental studies that rigorously demonstrate the effectiveness of the claimed scientific advance. On the other hand, the main purpose of a tool demo paper is not to rigorously justify the scientific advances of the tool (although the tool demo paper may contain a concise list of advances or references to other research papers). Rather, a tool demo paper should simply provide concise summary of the current state of a tool and describe how researchers in the PEPM community might apply it effectively.

Below we list the explicit evaluation criteria that will be used by the PEPM committee when selecting tool papers.

• Technical Foundations: In keeping with the overall goals of PEPM, described tools should be based on well-reasoned semantic principles. Even though the shorter length of tool papers will not allow authors to provide significant technical details of the theory underlying the tool, submissions should give a concise summary of the technical foundations and provide references to related work where more technical details are presented.
• Novelty: In contrast with regular PEPM submissions, PEPM tool demo papers may include work that has been published elsewhere. In the ideal case, the technical foundations of the tool will have been published previously, and the submitted PEPM tool paper will report on follow-on work that has produced a robust tool that has been applied to interesting examples. The PEPM program committee will consider accepting tool demo papers that describe tools that have been presented at other conferences/workshops if these conferences/workshops belong to a different community. For example, if a tool has been demonstrated at an operating system conference, the PEPM program committee might also consider accepting the same tool to be shown at PEPM if it is determined that the demo could provide interesting and new insights to the PEPM community. If tool demo papers are submitted for tools that have presented elsewhere, authors should include a statement in the paper that acknowledges previous demos and that justifies the benefits of presenting the tool again for the PEPM audience. In summary, the "novelty" expected of a tool demo paper is not "never been published before or presented elsewhere", but instead "new useful and practical information provided to the PEPM community".
• Stability: PEPM tool demo papers should describe tools with reasonably complete implementations. Tools where significant components are not fully implemented or tested and tools which have not been applied to interesting examples will not be considered. It is expected that tool demos will describe well-engineered internal architectures and interfaces.
• Robustness: Tool demo papers will also be evaluated for evidence of tool robustness. This might include evidence that the tool has been applied to a variety of examples, or used by others outside of the research group that developed the tools.
• Documentation: The tools should be presented on a web-site that includes documentation for installation and a user manual that describes the basic use of the tool, its options, and its application to at least on example.
• Example Repository: Ideally, tools should include a repository of examples (e.g., contained in the tool distribution or available on the tool web site) along with a description of how to run the tool on the examples.
• Publicly Availability: Preference will be given to tools that are freely available (e.g., downloadable from the tool web site) so that other researchers in the PEPM community can independently evaluate the tool. Exceptions may be made for tools from industry and commercial tools that cannot be made publicly available for business reasons.
• Interesting Public Presentation: Evaluation of tool demo papers will include an assessment of the potential quality of the tool demo (e.g., completeness of tool implementation, depth of functionality, quality of user interfaces, application and assessment of interesting examples) as presented in the attached appendix described above that outlines the demo session.

Authors with further questions about the structure, contents, or suitability of a potential tool demo paper should contact the program chairs.

What should a tutorial look like?

In case your tutorial is accepted, the following offers suggestions for preparing and presenting your tutorial.

1. Contents
   • When preparing the tutorial, keep your audience in mind.
   • People don't pay for a tutorial in order to hear things that they already know or that are irrelevant for their work.
   • Don't be vague, don't waste time with lengthy introductions, but speak to the point.
   • Don't try to impress the audience with the amount of your research, but convey practical knowledge and ideas that the participants will find useful for their own work.
   • Whenever possible, use examples and case studies and avoid lengthy abstract passages.
   • Consider demonstrations on video or an overhead panel.
   • In order to get an audience as homogeneous as possible, clearly state which knowledge you expect from the participants in the tutorial description.
2. Slides and notes
   • You will have to prepare tutorial notes for the participants.
   • These handouts usually contain copies of the slides that you show.
   • Use at least a 14 pt (or better an 18 pt) font on all of your slides.
   • A good slide should not just repeat everything you say but summarize your presentation.
   • Use short phrases and keywords instead of full sentences.
   • People cannot read as fast as you speak. Make heavy use of pictures and examples.
   • Use colors where they are helpful, but remember that they will not appear in the black and white handouts.
   • Don't put too much or too little material on a single slide.
   • A good rule of thumb is to spend 3 minutes per slide.
   • Don't include slides that you will skip in the presentation; people will find that annoying.
   • You will have to deliver the tutorial notes in camera-ready form before the conference. The deadline will be announced.
   • To avoid wasting paper, copy two slides on a single page (reduced size). The printed area of such a page must not exceed 27 x 17cm (10.5 x 6.7 inch).
   • In addition to the slide copies, also consider providing full-text handouts (papers, summaries, bibliography, etc.). Participants will appreciate that.
   • The maximum length of the notes for a half-day tutorial should be 50 pages for slide copies and another 20 pages for full-text material. For full-day tutorials these numbers can be doubled.
   • Try to achieve good printing quality.
   • We will add an uniform cover page to all tutorial notes.
   • Put slide numbers on the slides and page numbers on the pages.
3. Presentation
   • The participants expect that your presentation will be much easier to understand than a book about the same subject.
   • Speak clearly and lively. Try to interact with your audience.
   • Encourage the audience to ask questions.
   • A presentation is much more lively if it also includes examples and demonstrations on the blackboard, on video or on an overhead panel.
   • Tutorials should be split into sessions of 1.5 hours each with a 1/2 hour coffee break in between.
   • Don't overrun your tutorial time. After the tutorial the participants will be asked to assess the tutorial with a questionnaire.
   • A good rating will help you when applying for other tutorials in the future.

PEPM Proceedings is available for free download from ACM DL during the POPL week!

The PEPM Symposium/Workshop series aims at bringing together researchers and practitioners working in the areas of program manipulation, partial evaluation, and program generation. PEPM focuses on techniques, theory, tools, and applications of analysis and manipulation of programs.

The 2013 PEPM workshop will be based on a broad interpretation of semantics-based program manipulation and continue last years' successful effort to expand the scope of PEPM significantly beyond the traditionally covered areas of partial evaluation and specialization and include practical applications of program transformations such as refactoring tools, and practical implementation techniques such as rule-based transformation systems. In addition, the scope of PEPM covers manipulation and transformations of program and system representations such as structural and semantic models that occur in the context of model-driven development. In order to reach out to practitioners, a separate category of tool demonstration papers will be solicited.

Topics of interest for PEPM'13 include, but are not limited to:

• Program and model manipulation techniques such as: supercompilation, partial evaluation, fusion, on-the-fly program adaptation, active libraries, program inversion, slicing, symbolic execution, refactoring, decompilation, and obfuscation.

• Program analysis techniques that are used to drive program/model manipulation such as: abstract interpretation, termination checking, binding-time analysis, constraint solving, type systems, automated testing and test case generation.

• Techniques that treat programs/models as data objects including metaprogramming, generative programming, embedded domain-specific languages, program synthesis by sketching and inductive programming, staged computation, and model-driven program generation and transformation.

• Application of the above techniques including case studies of program manipulation in real-world (industrial, open-source) projects and software development processes, descriptions of robust tools capable of effectively handling realistic applications, benchmarking. Examples of application domains include legacy program understanding and transformation, DSL implementations, visual languages and end-user programming, scientific computing, middleware frameworks and infrastructure needed for distributed and web-based applications, resource-limited computation, and security.

To maintain the dynamic and interactive nature of PEPM, we will continue the category of `short papers' for tool demonstrations and for presentations of exciting if not fully polished research, and of interesting academic, industrial and open-source applications that are new or unfamiliar.

Student attendants with accepted papers can apply for a SIGPLAN PAC grant to help cover travel expenses and other support. PAC also offers other support, such as for child-care expenses during the meeting or for travel costs for companions of SIGPLAN members with physical disabilities, as well as for travel from locations outside of North America and Europe. For details on the PAC programme, see its web page.

All accepted papers, short papers included, will appear in formal proceedings published by ACM Press. In addition to printed proceedings, accepted papers will be included in the ACM Digital Library. Selected papers will be invited for a journal special issue of Science of Computer Programming dedicated to PEPM'13.

PEPM has established a Best Paper award. The winner will be announced at the workshop.

Authors must transfer copyright to ACM upon acceptance (for government work, to the extent transferable), but retain various rights. Authors are encouraged to publish auxiliary material with their paper (source code, test data, etc.); they retain copyright of auxiliary material. The SIGPLAN Republication Policy and ACM's Policy and Procedures on Plagiarism apply.

Follow this link for the complete Call for Papers. There is also a more compact plain-text version.

History
Previous Meetings
Journal Special Issues
Statistics

• MyName^? - myname@site.edu

Note: It is helpful to insert your name in alphabetical order (by first name -- ignore the "Main.") -- then you can find your name (or not) more easily if you wish to remove it or confirm that you are on the list.

Related topics: TWikiUsers, TWikiRegistration

TWiki.PEPM13 Web Preferences

The following settings are web preferences of the TWiki.PEPM13 web. These preferences overwrite the site-level preferences in TWikiPreferences, and can be overwritten by user preferences (your personal topic, i.e. TWikiGuest in the TWiki.Main web)

GPCE variables:

• Set URLPEPM13 = http://www.program-transformation.org/PEPM13
• Set URLFLYER = ?
• Set URLFLYERALT = ?
• Set URLPOPL13 = http://popl.mpi-sws.org/2013/
• Set URLLOCAL = ?
• Set URLNICE = ?

• Set PAPERPRESUBMISSION = Tue, October 2, 2012 (extended!)
• Set PAPERSUBMISSION = Sun, October 7, 2012, 23:59, GMT (extended!)
• Set PAPERNOTIFICATION = Tue, November 6, 2012
• Set PAPERCAMERAREADY = Wed, November 14, 2012

• Set EARLYREGISTRATION = ??, 2011
• Set LATEREGISTRATION = ??, 2011

• Set CONFERENCEDAYS = Mon-Tue, January 21-22, 2013

• Set VENUE = Rome, Italy

Preferences:

• Set WEBTITLE = ACM SIGPLAN 2013 Workshop on Partial Evaluation and Program Manipulation
• Set SHORTWEBTITLE = PEPM2013

• List of topics of the TWiki.PEPM13 web:
  • Set WEBTOPICLIST = Home | Changes | Index | Search | Go

• Web specific background color: (Pick a lighter one of the StandardColors)
  • Set WEBBGCOLOR = #D0D0D0

• Exclude web from a web="all" search: (Set to on for hidden webs)
  • Set NOSEARCHALL =

• Default template for new topics and form(s) for this web:
  • WebTopicEditTemplate^?: Default template for new topics in this web. (Site-level is used if topic does not exist)
  • TWiki.WebTopicEditTemplate: Site-level default template
  • TWikiForms: How to enable form(s)
  • Set WEBFORMS =

• Users or groups who are not / are allowed to view / change / rename topics in the PEPM13 web: (See TWikiAccessControl)
  • Set DENYWEBVIEW =
  • Set ALLOWWEBVIEW =
  • Set DENYWEBCHANGE =
  • Set ALLOWWEBCHANGE = PepmGroup
  • Set DENYWEBRENAME =
  • Set ALLOWWEBRENAME = PepmGroup

• Users or groups allowed to change or rename this WebPreferences topic: (I.e. TWikiAdminGroup)
  • Set ALLOWTOPICCHANGE = TWikiAdminGroup PepmGroup
  • Set ALLOWTOPICRENAME = TWikiAdminGroup PepmGroup

• Web preferences that are not allowed to be overridden by user preferences:
  • Set FINALPREFERENCES = WEBTOPICLIST, DENYWEBVIEW, ALLOWWEBVIEW, DENYWEBCHANGE, ALLOWWEBCHANGE, DENYWEBRENAME, ALLOWWEBRENAME

Notes:

• A preference is defined as:
  6 spaces * Set NAME = value
  Example:
  • Set WEBBGCOLOR = #FFFFC0
• Preferences are used as TWikiVariables by enclosing the name in percent signs. Example:
  • When you write variable %WEBBGCOLOR% , it gets expanded to #D0D0D0 .
• The sequential order of the preference settings is significant. Define preferences that use other preferences first, i.e. set WEBCOPYRIGHT before WIKIWEBMASTER since %WEBCOPYRIGHT% uses the %WIKIWEBMASTER% variable.
• You can introduce new preferences variables and use them in your topics and templates. There is no need to change the TWiki engine (Perl scripts).

Related Topics:

• TWikiPreferences has site-level preferences.
• TWikiUsers has a list of user topics. User topics can have optional user preferences.
• TWikiVariables has a list of common %VARIABLES%.
• TWikiAccessControl explains how to restrict access by users or groups.

• Topic index: List of PEPM13 topics in alphabetical order.
  |All|A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z|
  | All topics in BookView |

• Jump to topic: If you already know the name of the topic, enter the name of the topic into the GoBox at the top

• WebChanges: Find out what topics in PEPM13 have changed recently

• How to edit text:
  • Make changes to topics in GoodStyle,
  • Learn the TextFormattingRules, and
  • Have a look at the TextFormattingFAQ

HistoricalStatistics for TWiki.PEPM13 Web

Notes:

• Do not edit this topic, it is updated automatically. (You can also force an update)
• TWikiDocumentation tells you how to enable the automatic updates of the statistics.
• Suggestion: You could archive this topic once a year and delete the previous year's statistics from the table.

• RoadMap^?
• WebIndex: all topics in the PEPM13 web
• WebSearch: find topics

Tracking activity

• WebNews: selected changes
• WebChanges: recent changes
• WebNotify: email notification of changes
• WebStatistics: usage counts

Look and feel

• WebPreferences: values of variables
• WebContents^?: web specific entries in the side bar